+import javax.annotation.PreDestroy;

 @Service
 public class GenerateBeneficiaryService {
     private static final Logger logger = LoggerFactory.getLogger(GenerateBeneficiaryService.class);
     private ExecutorService executor = Executors.newCachedThreadPool();
     
+    @PreDestroy
+    public void cleanup() {
+        logger.info("Shutting down executor service");
+        executor.shutdown();
+        try {
+            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+                executor.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            executor.shutdownNow();
+            Thread.currentThread().interrupt();
+        }
+    }

 public void createFile() {
     logger.info("BengenApplication.createFile start");
     long strt = System.currentTimeMillis();

     Integer count = ConfigProperties.getInteger("no-of-benID-to-be-generate");
+    if (count == null || count <= 0) {
+        logger.error("Invalid or missing configuration for no-of-benID-to-be-generate");
+        throw new IllegalStateException("Invalid beneficiary ID count configuration");
+    }
+    
     List<Object[]> batchArgs = createBatchData(count);

     // Batch insert using JdbcTemplate
-    String sql = "INSERT INTO `db_identity`.`m_beneficiaryregidmapping` " +
+    String dbName = ConfigProperties.getString("database.name", "db_identity");
+    String sql = "INSERT INTO `" + dbName + "`.`m_beneficiaryregidmapping` " +
                  "(`BeneficiaryID`, `Provisioned`, `Deleted`, `CreatedDate`, `CreatedBy`) " +
                  "VALUES (?, b'0', b'0', ?, ?)";

     for (int i = 0; i < batchArgs.size(); i += BATCH_SIZE) {
         List<Object[]> batch = batchArgs.subList(i, Math.min(i + BATCH_SIZE, batchArgs.size()));
-        jdbcTemplate.batchUpdate(sql, batch);
+        try {
+            jdbcTemplate.batchUpdate(sql, batch);
+        } catch (Exception e) {
+            logger.error("Failed to insert batch starting at index {}: {}", i, e.getMessage());
+            throw new RuntimeException("Batch insert failed", e);
+        }
     }

     long fin = System.currentTimeMillis() - strt;
     logger.info("BengenApplication.createFile finish. time = " + fin + " ms.");
 }

 protected BigInteger generateNumN(int n) {
-    int[] source = new int[n];
-    int[] target = new int[n];
-
-    for (int i = 0; i < n; i++) {
-        source[i] = getRandomDigit();
-    }
-
-    for (int i = 0, j = n - 1; i < n; i++, j--) {
-        int num = (j == 0) ? getRandomDigit() : getRandomDigit() % j;
-        target[j] = source[i];
-        source[i] = num;
-    }
-
-    StringBuilder sb = new StringBuilder(n);
-    for (int value : target) {
-        sb.append(value);
-    }
-
-    return new BigInteger(sb.toString());
+    StringBuilder sb = new StringBuilder(n);
+    for (int i = 0; i < n; i++) {
+        sb.append(getRandomDigit());
+    }
+    return new BigInteger(sb.toString());
 }

 protected BigInteger generateNumN(int n) {
-    int[] source = new int[n];
-    int[] target = new int[n];
-
-    for (int i = 0; i < n; i++) {
-        source[i] = getRandomDigit();
-    }
-
-    for (int i = 0, j = n - 1; i < n; i++, j--) {
-        int num = (j == 0) ? getRandomDigit() : getRandomDigit() % j;
-        target[j] = source[i];
-        source[i] = num;
-    }
-
-    StringBuilder sb = new StringBuilder(n);
-    for (int value : target) {
-        sb.append(value);
-    }
-
-    return new BigInteger(sb.toString());
+    List<Integer> digits = IntStream.range(0, 10).boxed().collect(Collectors.toList());
+    Collections.shuffle(digits, new SecureRandom());
+    
+    StringBuilder sb = new StringBuilder(n);
+    for (int i = 0; i < n; i++) {
+        sb.append(digits.get(i));
+    }
+    return new BigInteger(sb.toString());
 }

+private static final SecureRandom SECURE_RANDOM = new SecureRandom();
+
 private int getRandomDigit() {
-    SecureRandom secureRandom = new SecureRandom();
-    return secureRandom.nextInt(10);
+    return SECURE_RANDOM.nextInt(10);
 }

 private int getRandomDigit() {
-    SecureRandom secureRandom = new SecureRandom();
-    return secureRandom.nextInt(10);
+    return ThreadLocalRandom.current().nextInt(10);
 }

+private static final SecureRandom SECURE_RANDOM = new SecureRandom();
+
 private int getRandomInRange(int min, int max) {
-    SecureRandom sr = new SecureRandom();
     if (min > max) {
         throw new IllegalArgumentException("min must be <= max");
     }
     if (max == Integer.MAX_VALUE) {
-        return sr.nextInt(max - min) + min;
+        // Handle MAX_VALUE case - use long to avoid overflow
+        return SECURE_RANDOM.nextInt(max - min + 1) + min;
     }
-    return sr.nextInt(min, max + 1); // safe here
+    return SECURE_RANDOM.nextInt(min, max + 1);
 }